use rand::Rng;

use super::util_string;


/// 获取新的 Option ，如果 Some ，但值是 0,仍返回 None
#[allow(dead_code)]
pub fn get_i32_option_trim(arg: Option<i32>) -> Option<i32> {
    match arg {
        Some(v) => {
            if v == 0 {
                return None;
            } else {
                return Some(v);
            }
        }
        None => return None,
    }
}

/// 获取新的 Option ，如果 Some ，但值是 0,仍返回 None
#[allow(dead_code)]
pub fn get_i32_trim(v: i32) -> Option<i32> {
    if v == 0 {
        return None;
    } else {
        return Some(v);
    }
}

/// 获取新的 Option ，如果 Some ，但值是空白字符串,仍返回 None
#[allow(dead_code)]
pub fn get_string_option_trim(arg: Option<String>) -> Option<String> {
    match arg {
        Some(v) => {
            if util_string::is_empty(v.as_str()) {
                return None;
            } else {
                return Some(v);
            }
        }
        None => return None,
    }
}

/// 获取新的 Option ，如果 Some ，但值是空白字符串,仍返回 None
#[allow(dead_code)]
pub fn get_string_trim(v: String) -> Option<String> {
    if util_string::is_empty(v.as_str()) {
        return None;
    } else {
        return Some(v);
    }
}

/// 获取一个i32类型的随机数
#[allow(dead_code)]
pub fn random_i32() -> i32 {
    // 创建一个随机数生成器
    let mut rng = rand::thread_rng();
    
    // 生成一个 i32 类型的随机数
    let random_number: i32 = rng.gen_range(1..=i32::MAX);

    random_number

}

/// 获取一个u32类型的随机数
#[allow(dead_code)]
pub fn random_u32() -> u32 {
    // 创建一个随机数生成器
    let mut rng = rand::thread_rng();
    
    // 生成一个 u32 类型的随机数
    let random_number: u32 = rng.gen_range(1..=u32::MAX);

    random_number
}

/// 获取一个随机字符串
/// len: 字符串长度
pub fn random_str(len: usize) -> String {
    //log::debug!("获取一个长度为:{} 的随机字符串", len);
    rand::thread_rng().sample_iter(&rand::distributions::Alphanumeric).take(len).map(char::from).collect::<String>()
}

/// 获取一个随机验证码（6位随机数字）
pub fn random_valid_code() -> i32 {
    // 创建一个随机数生成器
    let mut rng = rand::thread_rng();

    // 生成一个 6 位数的随机数字，范围从 100000 到 999999
    rng.gen_range(100000..1000000)
}

/// 数字转byte(低字节序)
#[allow(dead_code)]
pub fn i32_to_vec(v: i32) -> Vec<u8> {
    //let bytes = v.to_ne_bytes(); // 使用系统的字节序
    //let bytes = v.to_be_bytes(); // 高字节序
    let bytes = v.to_le_bytes(); // 低字节序
    return bytes.to_vec();
}

/// 数字转byte(低字节序)
#[allow(dead_code)]
pub fn i16_to_vec(v: i16) -> Vec<u8> {
    //let bytes = v.to_ne_bytes(); // 使用系统的字节序
    //let bytes = v.to_be_bytes(); // 高字节序
    let bytes = v.to_le_bytes(); // 低字节序
    return bytes.to_vec();
}

/// 数字转byte(低字节序)
#[allow(dead_code)]
pub fn u32_to_vec(v: u32) -> Vec<u8> {
    //let bytes = v.to_ne_bytes(); // 使用系统的字节序
    //let bytes = v.to_be_bytes(); // 高字节序
    let bytes = v.to_le_bytes(); // 低字节序
    return bytes.to_vec();
}

/// 数字转byte(低字节序)
#[allow(dead_code)]
pub fn u16_to_vec(v: u16) -> Vec<u8> {
    //let bytes = v.to_ne_bytes(); // 使用系统的字节序
    //let bytes = v.to_be_bytes(); // 高字节序
    let bytes = v.to_le_bytes(); // 低字节序
    return bytes.to_vec();
} 

/// byte转数字（低字节序）
#[allow(dead_code)]
pub fn bytes_le_to_u32(bytes:[u8; 4]) -> u32 {
    //let v = u32::from_ne_bytes(bytes); // 使用系统的字节序
    //let v = u32::from_be_bytes(bytes); // 高字节序
    let v = u32::from_le_bytes(bytes); // 低字节序
    return v;
}

/// byte转数字（高字节序）
#[allow(dead_code)]
pub fn bytes_be_to_u32(bytes:[u8; 4]) -> u32 {
    //let v = u32::from_ne_bytes(bytes); // 使用系统的字节序
    let v = u32::from_be_bytes(bytes); // 高字节序
    //let v = u32::from_le_bytes(bytes);
    return v;
}

/// byte转数字（低字节序）
#[allow(dead_code)]
pub fn bytes_le_to_u16(bytes:[u8; 2]) -> u16 {
    //let v = u32::from_ne_bytes(bytes); // 使用系统的字节序
    //let v = u32::from_be_bytes(bytes); // 高字节序
    let v = u16::from_le_bytes(bytes); // 低字节序
    return v;
}

/// byte转数字（高字节序）
#[allow(dead_code)]
pub fn bytes_be_to_u16(bytes:[u8; 2]) -> u16 {
    //let v = u16::from_ne_bytes(bytes); // 使用系统的字节序
    let v = u16::from_be_bytes(bytes); // 高字节序
    //let v = u16::from_le_bytes(bytes); // 低字节序
    return v;
}